Network-layer application-specific trust model

ABSTRACT

A data verification system facilitates verifying whether a CCN Content Object is authentic or trustworthy on behalf of an application. During operation, the system can obtain a stack requirement for a custom transport stack, which specifies at least a description for a verifier stack component that verifies a Content Object using a key identifier (KeyID) associated with a publisher. The system instantiates the verifier stack component in the custom stack, and can use the custom stack to obtain a verified Content Object. While using the custom stack, the system can push, to the custom stack, an Interest that includes a name for a piece of content and includes a KeyID associated with a content producer. The system then receives, from the custom stack, a Content Object which the verifier stack component has verified is signed by the content producer associated with the KeyID.

RELATED APPLICATION

The subject matter of this application is related to the subject matter of the following applications:

-   U.S. patent application Ser. No. 12/338,175 (Atty. Docket No.     PARC-20080626-US-NP), entitled “CONTROLLING THE SPREAD OF INTERESTS     AND CONTENT IN A CONTENT CENTRIC NETWORK,” by inventors Van L.     Jacobson and Diana K. Smetters, filed 18 Dec. 2008; -   U.S. patent application Ser. No. 13/847,814 (Atty. Docket No.     PARC-20120537-US-NP), entitled “ORDERED-ELEMENT NAMING FOR     NAME-BASED PACKET FORWARDING,” by inventor Ignacio Solis, filed 20     Mar. 2013 and -   U.S. patent application Ser. No. 14/337,026 (Atty. Docket No.     PARC-20140480US01), entitled “System for Distributing Nameless     Objects using Self-Certifying Names,” by inventor Marc E. Mosko,     filed 21 Jul. 2014;     the disclosures of which are incorporated by reference in their     entirety herein.

BACKGROUND

1. Field

This disclosure is generally related to Content Centric Networks. More specifically, this disclosure is related to a security component of a transport stack that verifies a Content Object on behalf of an application.

2. Related Art

The proliferation of mobile computing and cellular networks is making digital content more mobile than ever before. People can use their smartphones to generate content, to consume content, or even to provide Internet access to other computing devices that generate or consume content. Oftentimes, a device's network location can change as a person takes this device to a new physical location. This can make it difficult to communicate with this device under a traditional computer network (e.g., the Internet) when the device's new network location is not known.

To solve this problem, information centric network (ICN) architectures have been designed to facilitate accessing digital content based on its name, regardless of the content's physical or network location. Content centric networking (CCN) is one example of an ICN. Unlike traditional networking, such as Internet Protocol (IP) networks where packets are forwarded based on an address for an end-point, the CCN architecture assigns a routable name to content itself so the that content can be retrieved from any device that hosts the content.

A typical CCN architecture forwards two types of packets: Interests and Content Objects. Interests include a name for a piece of named data, and serve as a request for the piece of named data. Content Objects, on the other hand, typically include a payload, and are only forwarded along a network path that has been traversed by an Interest with a matching name, and traverse this path in the reverse direction taken by the Interest packet. Typical CCN architectures only send Content Objects as a response to an Interest packet; Content Objects are not sent unsolicited.

CCN architectures can ensure content authenticity by allowing publishers to sign content, which allows consumers to verify content signatures. However, typical CCN routers do not perform content signature verification on Content Objects to avoid incurring additional network latency. Some CCN routers also maintain a Content Store that caches content to minimize the round-trip-delay, by returning a cached Content Object whenever possible. However, content caching in routers opens the door for denial-of-service (DoS) attacks.

One such DoS attack involves content poisoning, where an adversary injects fake content into a router's cache to flood the CCN network with fake content that blocks access to legitimate content of the same name. Applications can avoid becoming victim to content poisoning attacks by enforcing the use of self-certifying content names, or by verifying that the returned Content Objects is signed by a trusted entity. However, this is only possible if the application knows the content's hash value ahead of time, or has access to a set of digital certificates that bind the Content Object to a trusted entity. Implementing client applications that enforce CCN security measures can increase the complexity of client applications, which can require the application's developer or local user to maintain an up-to-date set of trusted root certificates that can be used to verify Content Objects. Hence, implementing client applications that enforce CCN security measures can require significant development costs and on-going maintenance costs for the developer and the user.

SUMMARY

One embodiment provides a data verification system that facilitates verifying, on behalf of an application, whether a CCN Content Object is authentic or trustworthy. During operation, the system can obtain a stack requirement for a custom transport stack, which specifies at least a description for a verifier stack component that verifies Content Objects using publisher key identifiers (KeylDs). The system instantiates the verifier stack component in the custom stack based on the stack requirement, and can use the custom stack to obtain a verified Content Object that has been verified by the verifier stack component. While using the custom stack, the system can push, to the custom stack, an Interest that includes a name for a piece of content and includes a KeyID associated with a content producer. The system then receives, from the custom stack, a Content Object which the verifier stack component has verified to be signed by the content producer associated with the KeyID.

In some embodiments, the verifier stack component can verify Content Objects or Named Data Objects (NDO's) received over an Information Centric Network (ICN) or a Content Centric Network (CCN). In ICNs, each piece of content is individually named, and each piece of data is bound to a unique name that distinguishes the data from any other piece of data, such as other versions of the same data or data from other sources. This unique name allows a network device to request the data by disseminating a request or an Interest that indicates the unique name, and can obtain the data independent from the data's storage location, network location, application, and means of transportation. Named-data networks (NDN) or content-centric networks (CCN) are examples of an ICN architecture; the following terms describe elements of an NDN or CCN architecture:

Content Object:

A single piece of named data, which is bound to a unique name. Content Objects are “persistent,” which means that a Content Object can move around within a computing device, or across different computing devices, but does not change. If any component of the Content Object changes, the entity that made the change creates a new Content Object that includes the updated content, and binds the new Content Object to a new unique name.

Unique Names:

A name in a CCN is typically location independent and uniquely identifies a Content Object. A data-forwarding device can use the name or name prefix to forward a packet toward a network node that generates or stores the Content Object, regardless of a network address or physical location for the Content Object. In some embodiments, the name may be a hierarchically structured variable-length identifier (HSVLI). The HSVLI can be divided into several hierarchical components, which can be structured in various ways. For example, the individual name components parc, home, ndn, and test.txt can be structured in a left-oriented prefix-major fashion to form the name “/parc/home/ndn/test.txt.” Thus, the name “/parc/home/ndn” can be a “parent” or “prefix” of “/parc/home/ndn/test.txt.” Additional components can be used to distinguish between different versions of the content item, such as a collaborative document.

In some embodiments, the name can include an identifier, such as a hash value that is derived from the Content Object's data (e.g., a checksum value) and/or from elements of the Content Object's name. A description of a hash-based name is described in U.S. patent application Ser. No. 13/847,814 (entitled “ORDERED-ELEMENT NAMING FOR NAME-BASED PACKET FORWARDING,” by inventor Ignacio Solis, filed 20 Mar. 2013), which is hereby incorporated by reference. A name can also be a flat label. Hereinafter, “name” is used to refer to any name for a piece of data in a name-data network, such as a hierarchical name or name prefix, a flat name, a fixed-length name, an arbitrary-length name, or a label (e.g., a Multiprotocol Label Switching (MPLS) label).

Interest:

A packet that indicates a request for a piece of data, and includes a name (or a name prefix) for the piece of data. A data consumer can disseminate a request or Interest across an information-centric network, which CCN/NDN routers can propagate toward a storage device (e.g., a cache server) or a data producer that can provide the requested data to satisfy the request or Interest.

In some embodiments, the ICN system can include a content-centric networking (CCN) architecture. However, the methods disclosed herein are also applicable to other ICN architectures as well. A description of a CCN architecture is described in U.S. patent application Ser. No. 12/338,175 (entitled “CONTROLLING THE SPREAD OF INTERESTS AND CONTENT IN A CONTENT CENTRIC NETWORK,” by inventors Van L. Jacobson and Diana K. Smetters, filed 18 Dec. 2008), which is hereby incorporated by reference.

In some embodiments, the system can process a Content Object using the verifier stack component of the custom stack. While processing the Content Object, the system can use a verifier module to verify whether Content Object is signed by the content producer associated with the KeyID. Then, responsive to determining that the verifier module does not validate or invalidate the Content Object, the system processes the Content Object using one or more trust checkers to determine whether the Content Object is trustworthy.

In some variations to these embodiments, the system accepts the Content Object responsive to determining that at least one trust checker has determined the Content Object to be trustworthy.

In some variations to these embodiments, the system rejects the Content Object responsive to determining that at least one trust checker has determined the Content Object to not be trustworthy.

In some embodiments, the description of the verifier stack component includes a list of trusted certificate authorities.

In some embodiments, the description of the verifier stack component includes a listing of one or more trust checkers to instantiate in the verifier stack component. A respective trust checker can analyze a Content Object to accept the Content Object, reject the Content Object, or defer verification of the Content Object to another trust checker.

In some embodiments, the description of the verifier stack component includes an ordering for the one or more trust checkers in the verifier stack component.

In some embodiments, the description of the verifier stack component includes an implementation for a respective trust checker.

In some variations to these embodiments, the set of trust checkers can include a trust checker that rejects Content Objects with stale data.

In some variations to these embodiments, the set of trust checkers can include a trust checker that rejects a public key which is not published under a white-list name prefix.

In some variations to these embodiments, the set of trust checkers can include a trust checker which verifies a Content Object using a Pretty Good Privacy (PGP) web of trust.

In some embodiments, the system can receive, from an application, a control statement for the custom stack. The control statement includes a set of trust checkers to enable in the verifier stack component. The system then enables the set of trust checkers responsive to receiving the control statement.

In some embodiments, the system can receive, from an application, a control statement for the custom stack. The control statement can include a set of trust checkers to disable in the verifier stack component. The system then disables the set of trust checkers responsive to receiving the control statement.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 presents an exemplary computing environment that facilitates receiving verified Content Objects in accordance with an embodiment.

FIG. 2 presents a flow chart illustrating a method for instantiating or using a transport stack to receive verified Content Objects in accordance with an embodiment.

FIG. 3 presents a flow chart illustrating a method for using a security component of a transport stack to send messages over a Content Centric Network in accordance with an embodiment.

FIG. 4 illustrates an exemplary signer component of transport stack in accordance with an embodiment.

FIG. 5 presents a flow chart illustrating a method for verifying a Content Object received at a security component of a transport stack in accordance with an embodiment.

FIG. 6 illustrates an exemplary verifier component of a transport stack in accordance with an embodiment.

FIG. 7 illustrates an exemplary apparatus that facilitates receiving verified Content Objects in accordance with an embodiment.

FIG. 8 illustrates an exemplary computer system that facilitates receiving verified Content Objects in accordance with an embodiment.

In the figures, like reference numerals refer to the same figure elements.

DETAILED DESCRIPTION

The following description is presented to enable any person skilled in the art to make and use the embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present disclosure. Thus, the present invention is not limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.

OVERVIEW

Embodiments of the present invention provide a security stack component that solves the problem of verifying, on behalf of an application, whether a CCN Content Object is authentic or trustworthy. The verifier stack component can be instantiated within a stack of the transport framework, and performs transparent enforcement of the trust on behalf of the application or operating environment, without requiring the application or operating environment to be involved in verifying the Content Object.

For example, an Interest message can facilitate verifying a Content Object by specifying a public key of a content producer or specifying a self-certifying name for the Content Object. The self-certifying name can include an exact hash digest of the Content Object, and can be obtained, for example, from a Content Object Manifest that references a collection of data. Any entity that disseminates or forwards the Interest can use the public key or the self-certifying name to determine a trustworthiness of a Content Object received as a response to the Interest. If the entity knows the self-certifying name of the Content Object, this entity may not need to verify the signature of their corresponding Content Object; the entity may just compute and compare the Content Object's hash value to the self-certifying name.

In some embodiments, if the client wants to obtain a secure Content Object, the client can disseminate an Interest that includes a key identifier (KeyID) associated with the Content Object's content producer, and/or includes a ContentObjectHash field with the Content Object's hash. The KeyID is a hash of a public key for the content producer. When the network stack receives such an Interest, the verifier component of the network stack can use the KeyID and/or the ContentObjectHash fields to verify the authenticity and legitimacy of Content Objects with.

An application can use a transport stack on the local computer to disseminate the Interest for the Content Object, and expects to receive a verified Content Object that was indeed published by the content producer associated with the KeyID. The transport stack disseminates the Interest, and the verifier component can use the Interest's KeyID to verify the signature of the Content Object it receives to make sure the Content Object was signed by the trusted content producer.

To verify the Content Object, the verifier component needs to have access to the public key required to verify the Content Object, either from a local keychain or from a trusted third party (e.g., a certificate authority). Also, to make sure the public key is valid, the verifier component computes the hash of the public key, and compares this hash to the KeyID. The public key is valid if the public key's hash matches the KeyID.

Hence, the verifier component of the transport stack implements a generalized trust model that can be bootstrapped or configured at runtime to implement any application-specific trust model. This verifier component allows application developers to implement any robust and unique trust models that satisfy their application's need, can leverage absolute trust anchors (e.g., a certification authority identity and public key).

Exemplary Network Environment

In CCN, a forwarder maintains a forwarder information base (FIB) to control how Interests are forwarded across the CCN, maintains a pending Interest table (PIT) to return Content Objects along a return path established by the corresponding Interest, and maintains a content store (CS) to cache Content Objects. With the addition of content-restriction fields such as the KeyID and the ContentObjectHash values, the forwarder can operate on upstream Interests as follows:

-   -   1) The forwarder performs exact-name matching to search through         the CS for content that matches the Interest's name. If a match         is found, the cached content is returned to satisfy the         Interest.     -   2) If the CS search results in a miss, the forwarder searches         through the PIT for an entry with the same Interest name. If a         matching PIT entry is found, the forwarder aggregates the         Interest to the PIT entry, and records the arrival time and         interface in the PIT entry, without having to forward the         Interest.     -   3) If there is a CS miss and PIT miss, the forwarder creates a         new PIT entry for the Interest, and records the arrival time and         interface in the PIT entry. The forwarder then performs a         longest-prefix matching lookup in the FIB for an output         interface upon which to forward the Interest. If there exists         multiple matching FIB entries, the forwarder's the internal         scheduler prioritizes the routes as needed. The forwarder can         use secondary routes, for example, if an Interest times out on         the first, highest priority route.

For downstream Content Objects, the forwarder uses information in the PIT and CS to determine if the Content Object can be satisfied by any entry in the PIT. With the addition of fields such as KeyID and ContentObjectHash in interest messages, the forwarder limits objects which can be returned by the following rules:

-   -   1) The forwarder discards the Content Object if the hash digest         of the public key used to verify the signature of a Content         Object does not match the digest provided in the KeyID field of         the corresponding interest.     -   2) The forwarder discards the Content Object if the hash of the         Content Object does not match the digest provided in the         ContentObjectHash field.         If the forwarder does not discard the Content Object, the         forwarder searches for a PIT entry with a matching name. If a         matching PIT entry is found, the forwarder sends the Content         Object message to the downstream Interface upon which the         Interest arrived, and can also cache the Content Object in the         CS.

The CCN architecture also supports Manifest objects to encapsulate metadata for large chunks of content, as well as security and access control information. Manifest Content Objects have names that match the Interest, and can include a list of self-certifying Interest names (SCNs) for other pieces of content (e.g., for chunks of a large content file). Since the Manifest object is itself a Content Object and carries a signature, the list of SCNs can be trusted and used to issue a large number of interests with SCNs in parallel, thereby increasing throughput and removing the need for signature verification. A description of Manifests is described in U.S. patent application Ser. No. 14/337,026 (Atty. Docket No. PARC-20140480US01, entitled “System for Distributing Nameless Objects using Self-Certifying Names,” by inventor Marc E. Mosko, filed 21 Jul. 2014), which is hereby incorporated by reference.

Any device that disseminates an Interest for a Content Object can use the KeyID and/or the ContentObjectHash value. In embodiments of the present invention, the transport framework can verify a Content Object on behalf of an application that disseminated the corresponding Interest.

FIG. 1 presents an exemplary computing environment 100 that facilitates receiving verified Content Objects in accordance with an embodiment. Computing environment 100 can include a content centric network (CCN) 102, which can include any combination of wired and wireless networks, such as a Wi-Fi network, a cellular network, an Ethernet network, a fiber-optic network, and the Internet. CCN 102 can include a plurality of forwarders (e.g., routers and member computer nodes) that can forward Interests and Content Objects based on their name or name prefix. Computing environment 100 can also include a client 104 connected to CCN 102, such as a smartphone 104.1, a tablet computer 104.2, and/or a server or personal computer 104.m.

In the traditional IP architecture, a forwarder is an IP-based forwarder that looks at a packet's header to determine the source and the destination for the packet, and forwards the packet to the destination. The conventional stack performs TCP/UDP, and an application interacts with the stack via a socket. In contrast, device 104 of the present invention doesn't use such a conventional “stack.” Rather, device 104 implements a “transport framework” 106 which can dynamically configure a custom stack to satisfy an application's custom “environment execution context.”

Specifically, device 104 can include a transport framework 106 which can automatically create and/or update a custom stack 110 for a local application or the local operating environment (e.g., without intervention of a local user 116, the local operating environment, and/or any applications running on device 104). Device 104 can also include a forwarder 112 (e.g., a network interface card, or a router in a local area network), which can transfer packets between custom stacks of transport framework 106 and network 102. Custom stack 110 can process packets to and/or from forwarder 112 or any application running on device 104, and the stack's components can include any available components that can be organized in any order to satisfy the application's requirements.

In some embodiments, transport framework 106 can include a set of stack-configuring agents that can dynamically configure a stack on-demand. For example, transport framework 106 can include a set of transport API components 108 that implement functions accessible via a library and/or an API. An application can access an API implemented by transport framework 106 by issuing a call to transport framework 106. Transport framework 106 then maps the API call to a corresponding API component of components 108 that implements this specific function, and forwards the API call to this API component.

If a stack doesn't exist for processing the API call, the API component can configure or instantiates a custom stack that can perform the application's API call. For example, the API component can issue a request to transport framework 106, with a request describing the functionality of the custom stack. This functionality description can be high-level, such as to specify a pre-defined behavior or operation that is to be performed on data packets. Transport framework 106 then realizes this behavior or operation by organizing the necessary components into a custom stack 110 (e.g., in custom stack components) in an order that achieves the desired behavior or operation.

Alternatively, the functionality description can be low-level, such as to specify the specific stack components that are to be used, and can specify an order in which the stack components are to be arranged. Moreover, the functionality description can also be specific or generic with respect to the individual components, for example, to request a specific “security component” (e.g., a PKI verification component) or to request any “verification component.”

Each component in custom stack 110 has a tuple of input and output queues, such as an OutputQueueDown queue and an InputQueueDown queue for sending and receiving messages to/from the next lower component in the stack, respectively. The input and output queues also include an OutputQueueUp queue and an InputQueueUp queue for sending and receiving messages to/from the next higher component in the stack, respectively. Egress messages flow through components of tack 110 one at a time through the downward queues (e.g., from component 120 toward component 124), where each component reads, processes, and forwards the messages as needed. Ingress messages, on the other hand, flow through the stack 110 upward from component 124 toward component 120. The top stack component 120 in stack 110 interfaces with transport API components 108, and the bottom stack component 124 interfaces with forwarder 112.

In some embodiments, stack 110 can include a security component 122 that performs transparent enforcement of the trust on behalf of the application or operating environment, without requiring the application or operating environment to be involved in verifying the Content Object. For example, security component 122 can include a signer component 124 and a verifier component 126. When security component 122 receives an Interest from an application, signer 124 can store the Interest in a local repository to make the Interest's KeyID or ContentObjectHash value accessible by the verifier 126.

Verifier 126 performs the operations to obtain the necessary public key associated with an Interest's KeyID, verifying the public key, and verifying the Content Object whose name prefix matches the Interest's name. Verifier 126 can perform a remedial action when a public key fails verification (e.g., by requesting another public key), and can perform a remedial action when a Content Object fails verification (e.g., by disseminating the Interest to request another Content Object that may pass verification).

In some embodiments, the Content Object can include a Manifest. Manifests include a listing of one or more Content Objects that are part of a larger collection, such as a movie file. The Manifest itself can also include a signature that can be used to verify the Manifest against a publisher's public key or KeyID. Also, the Manifest includes any other information that is necessary for verifying the Manifest, such as a reference to a certificate that includes the public key that was used to sign the Manifest. Verifier 126 can perform PKI verification by using this reference to fetch the certificate from a trusted third party, and determining whether security component 122 can trust the certificate (e.g., by following a chain of trust from a trusted root certificate to the Manifest's certificate).

If verification of the Manifest's certificate is successful, verifier 126 obtains the public key from the certificate, and verifies the public key using the KeyID. If verification of the public key is successful, verifier 126 uses the public key to verify the Manifest's signature. If the Manifest's signature is successful, verifier 126 proceeds to send the Manifest to a higher stack component in transport stack 110 (e.g., to a Manifest-handling stack component, or to the application or operating environment that requested the Manifest).

Verifier 126 also includes a trust circuit that can verify the Content Object based on additional attributes of the Content Object. For example, if PKI verification cannot be used to accept or reject the Content Object (e.g., if verifier 126 cannot obtain the KeyID, the public key, or a certificate), verifier 126 can defer verification to the trust circuit. This trust circuit implements more complex trust verification techniques that are beyond the standard PKI verification framework. For example, the trust circuit can include a sequence of trust checkers that can be defined by the application or the operating environment via the transport framework API.

Some example trust checks can include:

-   -   A trust checker that rejects stale data (e.g., data older than n         days)     -   A trust checker that rejects Content Objects whose public key is         obtained from a namespace not in a namespace whitelist or from a         namespace in a namespace blacklist     -   A trust checker that validates Content Objects using a Pretty         Good Privacy (PGP) peer web of trust.

In some embodiments, the application or the operating environment can provide the instructions that implement a trust checker to the API 108 of Transport Framework 106 when instantiating security component 122 in custom stack 110. The application can also provide a list of pre-defined checkers to instantiate for the trust circuit, and can provide an order in which these trust checkers are to be instantiated in security component 122.

Verifier 126 can include a Control Point Interface (CPI) agent, which accepts control statements from the application at runtime. The application can use the CPI to select, at runtime, which subset of trust checkers the application wants to enable or disable for a given Interest (and the matching Content Object), or for any future Interests and Content Objects. Hence, when a trust checker is turned off, the trust circuit can bypass the trust checker to forward all checks onto the next trust checker in the sequence of trust checkers.

FIG. 2 presents a flow chart illustrating a method 200 for instantiating or using a transport stack to receive verified Content Objects in accordance with an embodiment. During operation, the transport framework can receive an API call from an application (operation 202). This API call can include instructions to instantiate or update a stack that is to be used by the application, or can include messages which the application needs to transmit over the computer network. Hence, the transport framework determines whether the API call includes stack requirements, or includes a CCN message (operation 204). If the API call includes stack requirements, the transport framework instantiates or updates a transport stack so that it satisfies the stack requirements (operation 206).

On the other hand, if the API call includes a CCN message, the transport framework identifies a transport stack associated with the API call (operation 208), and forwards the CCN message to the identified transport stack (operation 210). Also, recall that a CCN message may include an Interest that serves as a request for a piece of data, or may include a data object that carries data for the local application (e.g., a CCN Content Object that includes data requested via an Interest). Hence, the transport framework may analyze the CCN message to determine whether the message includes an Interest (operation 212). If so, the transport framework may receive a verified Content Object from the transport stack (operation 214), which was verified by the verifier component of the transport stack. The transport framework then returns the verified Content Object to the application (operation 216).

During operation 206, when instantiating the transport stack, the application or the transport framework can bootstrap the verifier component to uphold a desired trust model. For example, a local web browser can be preconfigured with a set of root Certificate Authority (CA) certificates which the browser can use to validate the signed data it receives. The web browser can instantiate a custom transport stack that includes the verifier component, and bootstraps the verifier component to include this set of root CA certificates. Then, when establishing TLS sessions over HTTPS, the verifier can traverse the certificate chain starting at the target server and ending with a trusted CA certificate, which validates the legitimacy of the public-key used to encrypt and/or sign the data. If the target server's certificate chain is not rooted in one of the default root CA certificates, then the public key is not trusted, and the user is typically alarmed. The browser application no longer needs to traverse the certificate chain itself to validate signed or encrypted data packets.

Recall that the stack components can include a Control Plane Interface (CPI) that serves to configure components in the transport stack. In some embodiments, the local application can use the CPI to issue a CPI call directly to the security component or verifier component, to send configuration information that reconfigures or updates the trust model of the verifier component. The CPI call can include a CCN message can encapsulate JSON-encoded commands, and is sent asynchronously from the CPI to the target stack component (e.g., the security component or the verifier component) to modify the stack component's internal state.

The command in the CCN message includes an object with a command identifier (string) and payload (options) for the command. For example, to cancel a flow controller session for a particular namespace prefix, a JSON-encoded command wrapped in a CCN Message is sent to the FlowController component. An exemplary JSON-encoded CPI command is presented in Table 1.

TABLE 1   {  CMD   : ″CONTROLFLOW_CANCEL_FLOW″,  PAYLOAD : {   flow-name : <flowname>  } }

When the transport framework receives a CPI call, the transport framework can asynchronously invoke the CPI event handler (CPI agent) that parses the CCN Message instance, extracts the command identifier and associated options payload from the JSON object, and performs a lookup to identify a stack component that has registered itself with the command identifier. The CPI event handler then forwards the CCN Message instance to the matching stack component that performs the command's operation (e.g., to cancel the flow session).

In some embodiments, the verifier component can register CPI commands with the CPI event handler. Two exemplary commands include a whitelist modification command and a blacklist modification command. The whitelist command (or blacklist command) can add (remove) a whitelist source and remove (add) a blacklist source from the trust circuit gate in the verifier component of the stack. The options payload for a whitelist command or a blacklist command can include a set of keys, and has for each key a list of namespace prefixes that are to be added or removed to/from the whitelist source or blacklist source.

In some embodiments, the default behavior for the last gate in the trust circuit may be set to automatically reject messages, since they have not been verified by any of the prior gates. However, application developers may wish to negate this behavior to be more trustworthy. Another exemplary CPI command registered by the verifier component can include a “set trust circuit end-gate defer action” command that configures the default behavior of the last trust checker in the verifier component's trust circuit.

Yet another exemplary command registered by the verifier component can include a “toggle advanced trust circuit gates” that enables or disables the trust circuit in the verifier component. When enabled, the verifier component forwards incoming messages into the test circuit if they pass the basic trust policy test. If disabled, only the basic trust policy test will be enforced and the verifier component does not forward messages to the trust circuit.

Network-Layer Security Component

FIG. 3 presents a flow chart illustrating a method 300 for using a security component of a transport stack to send messages over a Content Centric Network in accordance with an embodiment. During operation, a signer component of the security component can receive a message from an application (operation 302), and analyzes the message to determine its contents (operation 304).

Recall that an application can disseminate an Interest that includes a KeyID to request a Content Object which has been signed by an entity associated with the KeyID. For this reason, the security component stores Interest messages so that the security component can access their KeyID when verifying their matching Content Objects. Hence, while analyzing the message, the signer determines whether the message includes an Interest (operation 306), and if so, the signer can store the Interest in association with the application (operation 308). The signer then forwards the message to another component of the transport stack (operation 310).

On the other hand, if the message does not includes an Interest (e.g., the message include Content Object, or any other data object that needs to be transmitted over the computer network), the signer determines whether the message needs to be signed (operation 312). If the message does not need to be signed, the signer proceeds to forward the message to the next component of the transport stack (operation 310). Otherwise, the signer proceeds to sign the message (operation 314) before forwarding the message to the next component of the transport stack (operation 310).

FIG. 4 illustrates an exemplary signer component 400 of transport stack in accordance with an embodiment. Signer component 400 can include a packet analyzer 406 and a packet signer 408. Moreover, signer component 400 can obtain messages from the security component's upper stack component output queue 402 (e.g., message outputs from the upper stack component). After processing an input message, signer component 400 forwards the output message to the security component's lower stack component input queue 404 (e.g., message inputs to the lower stack component).

Recall that the security component enforces trust management on pairs of Interests and Content Objects. For example, an ingress Content Object received by the verifier component needs to be associated with an egress Interest that was issued by an application. Because of this, packet analyzer 406 analyzes messages to detect Interests, and caches these Interests in an Interest repository 410 (e.g., a queue) as they flow through signer component 400. The verifier component can access Interest repository 410 to find a matching Interest to the Content Objects it receives.

In normal operation, Interest messages bypass packet signer 408. Hence, packet analyzer 406 forwards Interests to lower stack component input queue 404. On the other hand, when packet analyzer 406 detects a Content Object, packet analyzer 406 forwards the Content Object to packet signer 408 that signs the Content Object as it passes through signer component 400.

FIG. 5 presents a flow chart illustrating a method 500 for verifying a Content Object received at a security component of a transport stack in accordance with an embodiment. During operation, a verifier component of the security component can receive a Content Object (operation 502). The verifier processes the Content Object by searching a local repository for a KeyID associated with the Content Object's name (operation 504), and determining whether a KeyID was found (operation 506).

If a KeyID was found, the verifier component verifies whether the Content Object was signed by a content producer associated with the KeyID (operation 508). Also, if verification was successful, the verifier accepts the Content Object (operation 512), and proceeds to forward the verified Content Object to the application which disseminated the corresponding Interest (operation 514).

On the other hand, if a KeyID was not found (operation 506), or if verification was not conclusive (operation 510), the verifier can process the Content Object using one or more trust checkers to determine whether the Content Object is trustworthy (operation 514). Some example trust checks can include:

-   -   A trust checker that rejects stale data.     -   A trust checker that rejects Content Objects whose public key is         obtained from a namespace not in a namespace whitelist or from a         namespace in a namespace blacklist     -   A trust checker that validates Content Objects using a Pretty         Good Privacy (PGP) peer web of trust.

The verifier then determines whether the trustworthy checks determined that the Content Object is trustworthy (operation 516). If the Content Object is trustworthy, the verifier accepts the Content Object and forwards the Content Object to the application (operation 512). Otherwise, the verifier rejects the Content Object (operation 518), and may perform a remedial action. The remedial action can include, for example, writing the failed verification operation in a log file, informing the application of the failed verification check (and providing the Content Object to the application), and storing the Content Object in a repository of rejected Content Objects.

Another remedial action may include blacklisting the content producer which returned the Content Object, and/or re-submitting the Interest to obtain another matching Content Object from another content producer. This allows the verifier component to initiate additional attempts at obtaining a verifiable Content Object on behalf of the application.

FIG. 6 illustrates an exemplary verifier component 600 of a transport stack in accordance with an embodiment. Verifier component 600 can include a verification checker 608 and a test circuit 610. Moreover, verifier component 600 can obtain messages from the security component's lower stack component output queue 402 (e.g., message outputs from the lower stack component). After verifying an input message, verifier component 600 forwards the accepted output message to the security component's upper stack component input queue 604 (e.g., message inputs to the upper stack component), and stores the rejected messages in a reject repository 606.

Recall that the security component enforces trust management on pairs of Interests and Content Objects. When verifier component 600 receives an ingress Content Object, verifier component 604 performs a lookup operation in an Interest repository 604 to search for the corresponding egress Interest message that was issued by a local application. Verification checker 608 uses the KeyID and the ContentObjectHash of the egress Interest message to verify the Content Object.

Test circuit 610 can perform advanced trust policy enforcement on the Content Objects, which involves processing the Content Object using one or more trust checkers 612.

For example, a key namespace checker 612.1 can check whether the public key used to verify the signature of a Content Object was generated by a key belonging to a trusted namespace. For example, content published under the “/pax” namespace can be signed by a key belonging to the “/xerox” namespace, such that the “/xerox” namespace is a whitelisted namespace to trust any keys published under the “/xerox” namespace.

In some embodiments, verification checker 608 can use a flat trust model, which is a special case of a hierarchical PKI trust model. Specifically, in the flat trust model, an application explicitly identifies the certificates of Content Objects the application trust. Verification checker 608 only accepts Content Objects signed using these identified certificates, and as a result, does not need to perform certificate chain traversal.

A stale data checker 612.2 can check whether the signature of a Content Object is not older than a predetermined time range, such as a week, month, a year, etc.

A tail checker 612.n can perform a preconfigured operation, such as to accept messages by default or reject messages by default. An application can configure the default operation via the CLI for verifier component 600.

A web of Trust (WOT) checker (not shown in FIG. 6) can maintain a cache of self-signed trusted identities (e.g., public key hashes), and uses this identities cache to enforce a web-of-trust model. Content Objects are deemed trusted if they are signed by a trusted key. When a new identity Content Object is received and passed into trust circuit 610, the WOT checker can check whether the verification key was signed by one of the already-trusted identities in the trusted identity cache. If so, the verification key is accepted and a reference count associated with the new identity is incremented. In some embodiments, the WOT checker can grow the set of trusted keys organically. For example, if a reference count for a new identity exceeds a predetermined threshold (e.g., three valid references), then the WOT checker can add this new identity to the trusted identity cache.

The web-of-trust model is a decentralized alternative to the more centralized PKI model. The fundamental idea of the web-of-trust model is that nodes can independently elect to trust an identity and public-key binding certificate without the presence of a trusted CA. More specifically, nodes can vouch for the trustworthiness of certificates individually or as a group. Nodes can either be partially trusted or fully trusted. Fully trusted nodes which vouch for a certificate binding automatically extend the “web of trust.” Conversely, a group of nodes (e.g., three or more) must vouch for the same certificate binding before the “web of trust” is expanded.

For example, a movie streaming service running on CCN can categorize content hierarchically based on content type (e.g., movie, television), genre (e.g., action, comedy, romance), and year. To simplify key management, a hierarchy of keys for each name prefix may also be used. For example, the named data object (NDO) with name “/netflix/movie/action/2013/TheAvengers” may be signed by a key named “/netflix/movie/action/2013/key,” which is in turn signed by a key named “/netflix/movie/action/key,” and so on, up to the root key named “/netflix/key,” which is signed by a trusted CA. With this type of trust model, the Content Object associated with the name “/netflix/movie/action/2013/TheAvengers” is trusted if the key chain from “/netflix/movie/action/2013/key” to “/netflix/key” is verified successfully.

To implement and enforce this particular trust model in CCN, an application developer would only be required to complete the following two steps:

-   -   1) Obtain public key of the CA which issued the trusted Netflix         key offline via electronic distribution or online netflix via a         KRS-like service.     -   2) Add this key to the trusted whitelist of the Verifier         component via the CPI.

As a further optimization to avoid lengthy certificate chain traversal, the application developer could acquire and cache certificates associated with sub-namespaces within the Netflix naming hierarchy and add them to the trusted whitelist within the stack. F or example, the certificates associated with the name prefix “/netflix/key,” “/netflix/movie/key,” and “/netflix/movie/action/key” could all be added in the trusted whitelist to circumvent certificate chain traversal for Content Objects belonging to the “/netflix/movie/action/” namespace.

As an alternate example, consider an application that implements a PGP-like web-of-trust model. As previously described, the set of trusted identities (e.g., public keys and self-signed certificates) expands in a user-based collaborative manner. Specifically, if more than three identities vouch for the trustworthiness of another previously untrusted identity, then the application can deem the identity to be trusted by consensus. In this example, we assume all identities are self-signed, which means that the organic growth of the set of trusted identities grows only by user group consensus.

To implement and abide by this particular type of trust model, an application developer need only instantiate verifier component 600 with a trust circuit 610 that contains a web-of-trust (WOT) checker. Then, the application can use the CPI to specify a preliminary set of trusted identities in the WOT checker. The WOT checker caches these trusted identities for future operation, which are each specified as hashes of their public keys.

FIG. 7 illustrates an exemplary apparatus 700 that facilitates receiving verified Content Objects in accordance with an embodiment. Apparatus 700 can comprise a plurality of modules which may communicate with one another via a wired or wireless communication channel. Apparatus 700 may be realized using one or more integrated circuits, and may include fewer or more modules than those shown in FIG. 7. Further, apparatus 700 may be integrated in a computer system, or realized as a separate device which is capable of communicating with other computer systems and/or devices. Specifically, apparatus 700 can comprise a stack-interfacing module 702, a stack-configuring module 704, a verifier module 706, and a forwarder module 708.

In some embodiments, stack-interfacing module 702 can obtain a stack requirement for a custom stack, and can forward packets between an application and the custom stack. Stack-configuring module 704 can instantiate or configure a stack to satisfy the stack requirements.

Verifier module 706 can process a Content Object for the custom stack to verify whether the Content Object is signed by the content producer associated with a given KeyID. Forwarder module 708 can forward CCN Messages between a local stack and a computer network (e.g., a content centric network).

FIG. 8 illustrates an exemplary computer system 802 that facilitates receiving verified Content Objects in accordance with an embodiment. Computer system 802 includes a processor 804, a memory 806, and a storage device 808. Memory 806 can include a volatile memory (e.g., RAM) that serves as a managed memory, and can be used to store one or more memory pools. Furthermore, computer system 802 can be coupled to a display device 810, a keyboard 812, and a pointing device 814. Storage device 808 can store operating system 816, a data verification system 818, and data 828.

Data verification system 818 can include instructions, which when executed by computer system 802, can cause computer system 802 to perform methods and/or processes described in this disclosure. Specifically, data verification system 818 may include instructions for obtaining a stack requirement for a custom stack, and for forwarding packets between an application and the custom stack (stack-interfacing module 820). Further, data verification system 818 can include instructions for instantiating or configuring a stack to satisfy the stack requirements (stack-configuring module 822).

Data verification system 818 can include instructions for processing a Content Object for the custom stack to verify whether the Content Object is signed by the content producer associated with a given KeyID (verifier module 824). Data verification system 818 can also include instructions for forwarding CCN Messages between a local stack and a computer network (e.g., a content centric network) (forwarder module 826).

Data 828 can include any data that is required as input or that is generated as output by the methods and/or processes described in this disclosure.

The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. The computer-readable storage medium includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer-readable media now known or later developed.

The methods and processes described in the detailed description section can be embodied as code and/or data, which can be stored in a computer-readable storage medium as described above. When a computer system reads and executes the code and/or data stored on the computer-readable storage medium, the computer system performs the methods and processes embodied as data structures and code and stored within the computer-readable storage medium.

Furthermore, the methods and processes described above can be included in hardware modules. For example, the hardware modules can include, but are not limited to, application-specific integrated circuit (ASIC) chips, field-programmable gate arrays (FPGAs), and other programmable-logic devices now known or later developed. When the hardware modules are activated, the hardware modules perform the methods and processes included within the hardware modules.

The foregoing descriptions of embodiments of the present invention have been presented for purposes of illustration and description only. They are not intended to be exhaustive or to limit the present invention to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art. Additionally, the above disclosure is not intended to limit the present invention. The scope of the present invention is defined by the appended claims. 

What is claimed is:
 1. A computer-implemented method, comprising: obtaining a stack requirement for a custom stack, wherein the stack requirement specifies at least a description for a verifier stack component which verifies a Content Object using a key identifier (KeyID) associated with a publisher; instantiating the verifier stack component in the custom stack; and using the custom stack to obtain a verified Content Object, which involves: pushing, to the custom stack, an Interest that includes a name for a piece of content and includes a KeyID associated with a content producer; and receiving, from the custom stack, a Content Object which the verifier stack component has verified is signed by the content producer associated with the KeyID.
 2. The method of claim 1, further comprising processing a Content Object using the verifier stack component of the custom stack, wherein processing the Content Object involves: using a verifier module to verify whether Content Object is signed by the content producer associated with the KeyID; and responsive to determining that the verifier module does not validate or invalidate the Content Object, processing the Content Object using one or more trust checkers to determine whether the Content Object is trustworthy.
 3. The method of claim 2, further comprising: accepting the Content Object responsive to determining that at least one trust checker has determined the Content Object to be trustworthy.
 4. The method of claim 2, further comprising: rejecting the Content Object responsive to determining that at least one trust checker has determined the Content Object to not be trustworthy.
 5. The method of claim 1, wherein the description of the verifier stack component includes a list of trusted certificate authorities.
 6. The method of claim 1, wherein the description of the verifier stack component includes one or more of: a listing of one or more trust checkers to instantiate in the verifier stack component, wherein a respective trust checker analyzes a Content Object to accept the Content Object, reject the Content Object, or defer verification of the Content Object to another trust checker; an ordering for the one or more trust checkers in the verifier stack component; and an implementation for a respective trust checker.
 7. The method of claim 6, wherein the set of trust checkers includes one or more of: a trust checker that rejects Content Objects with stale data; a trust checker that rejects a public key which is not published under a white-list name prefix; and a trust checker which verifies a Content Object using a Pretty Good Privacy (PGP) web of trust.
 8. The method of claim 1, further comprising: receiving, from an application, a control statement for the custom stack, wherein the control statement includes a set of trust checkers to enable in the verifier stack component; and enabling the set of trust checkers.
 9. The method of claim 1, further comprising: receiving, from an application, a control statement for the custom stack, wherein the control statement includes a set of trust checkers to disable in the verifier stack component; and disabling the set of trust checkers.
 10. A non-transitory computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method, comprising: obtaining a stack requirement for a custom stack, wherein the stack requirement specifies at least a description for a verifier stack component which verifies a Content Object using a key identifier (KeyID) associated with a publisher; instantiating the verifier stack component in the custom stack; and using the custom stack to obtain a verified Content Object, which involves: pushing, to the custom stack, an Interest that includes a name for a piece of content and includes a KeyID associated with a content producer; and receiving, from the custom stack, a Content Object which the verifier stack component has verified is signed by the content producer associated with the KeyID.
 11. The storage medium of claim 10, wherein the method further comprises processing a Content Object using the verifier stack component of the custom stack, wherein processing the Content Object involves: using a verifier module to verify whether Content Object is signed by the content producer associated with the KeyID; and responsive to determining that the verifier module does not validate or invalidate the Content Object, processing the Content Object using one or more trust checkers to determine whether the Content Object is trustworthy.
 12. The storage medium of claim 11, wherein the method further comprises: accepting the Content Object responsive to determining that at least one trust checker has determined the Content Object to be trustworthy.
 13. The storage medium of claim 11, wherein the method further comprises: rejecting the Content Object responsive to determining that at least one trust checker has determined the Content Object to not be trustworthy.
 14. The storage medium of claim 10, wherein the description of the verifier stack component includes a list of trusted certificate authorities.
 15. The storage medium of claim 10, wherein the description of the verifier stack component includes one or more of: a listing of one or more trust checkers to instantiate in the verifier stack component, wherein a respective trust checker analyzes a Content Object to accept the Content Object, reject the Content Object, or defer verification of the Content Object to another trust checker; an ordering for the one or more trust checkers in the verifier stack component; and an implementation for a respective trust checker.
 16. The storage medium of claim 15, wherein the set of trust checkers includes one or more of: a trust checker that rejects Content Objects with stale data; a trust checker that rejects a public key which is not published under a white-list name prefix; and a trust checker which verifies a Content Object using a Pretty Good Privacy (PGP) web of trust.
 17. The storage medium of claim 10, wherein the method further comprises: receiving, from an application, a control statement for the custom stack, wherein the control statement includes a set of trust checkers to enable or disable in the verifier stack component; and enabling or disabling the set of trust checkers.
 18. An apparatus comprising: a stack-interfacing module to obtain a stack requirement for a custom stack, wherein the stack requirement specifies at least a description for a verifier stack component which verifies a Content Object using a key identifier (KeyID) associated with a publisher; and a stack-configuring module to instantiating the verifier stack component in the custom stack; wherein the stack-interfacing module is further configured to use the custom stack to obtain a verified Content Object, which involves: pushing, to the custom stack, an Interest that includes a name for a piece of content and includes a KeyID associated with a content producer; and receiving, from the custom stack, a Content Object which the verifier stack component has verified is signed by the content producer associated with the KeyID.
 19. The apparatus of claim 18, further comprising a verifier module to process a Content Object for the custom stack, wherein processing the Content Object involves: verifying whether the Content Object is signed by the content producer associated with the KeyID; and responsive to determining that the verifier module does not validate or invalidate the Content Object, processing the Content Object using one or more trust checkers to determine whether the Content Object is trustworthy.
 20. The apparatus of claim 19, wherein the verifier module is further configured to accept the Content Object responsive to determining that at least one trust checker has determined the Content Object to be trustworthy.
 21. The apparatus of claim 19, wherein the verifier module is further configured to reject the Content Object responsive to determining that at least one trust checker has determined the Content Object to not be trustworthy.
 22. The apparatus of claim 18, wherein the description of the verifier stack component includes a list of trusted certificate authorities.
 23. The apparatus of claim 18, wherein the description of the verifier stack component includes one or more of: a listing of one or more trust checkers to instantiate in the verifier stack component, wherein a respective trust checker analyzes a Content Object to accept the Content Object, reject the Content Object, or defer verification of the Content Object to another trust checker; an ordering for the one or more trust checkers in the verifier stack component; and an implementation for a respective trust checker.
 24. The apparatus of claim 23, wherein the set of trust checkers includes one or more of: a trust checker that rejects Content Objects with stale data; a trust checker that rejects a public key which is not published under a white-list name prefix; and a trust checker which verifies a Content Object using a Pretty Good Privacy (PGP) web of trust.
 25. The apparatus of claim 18, wherein the verifier module is further configured to: receiving, from an application, a control statement that includes a set of trust checkers to enable or disable in the verifier stack component; and enabling or disabling the set of trust checkers. 